-# Stream agent response
-response_text = ""
-async for chunk in agent.stream_response(conv.messages):
-    if chunk:
-        response_text += chunk
-        await websocket.send_text(json.dumps({
-            "type": "chunk",
-            "content": chunk
-        }))
+# In src/gpt_computer_agent/core/agent.py, add the stream_response method to GPTChatAgent:
 
+async def stream_response(self, messages: List[Dict[str, Any]]):
+    """Stream the agent's response."""
+    self.messages = messages
+    try:
+        stream = self.client.chat.completions.create(
+            model="gpt-4",
+            messages=self.messages,
+            temperature=self.config.temperature,
+            max_tokens=1000,
+            stream=True,
+        )
+        for chunk in stream:
+            content = chunk.choices[0].delta.content
+            if content:
+                yield content
+    except Exception as e:
+        logger.error(f"Error in agent stream_response: {e}")
+        raise
+
+# No changes are needed in src/gpt_computer_agent/api/app.py, but the above implementation is required for it to work.
+

+def update_conversation_metadata(self, conversation_id: str, title: str, updated_at: datetime) -> None:
+    """Update a conversation's metadata in the database."""
+    with sqlite3.connect(self.db_path) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            UPDATE conversations
+            SET title = ?, updated_at = ?
+            WHERE id = ?
+            """,
+            (title, updated_at.isoformat(), conversation_id)
+        )
+        conn.commit()
+
 def _save_conversation(self, conversation: Conversation) -> None:
-    """Save a conversation to the database."""
+    """Save a new conversation to the database."""
     with sqlite3.connect(self.db_path) as conn:
         cursor = conn.cursor()
         
-        # Insert or update conversation
+        # This method should only be used for creating new conversations.
+        # Use INSERT and expect it to be a new conversation.
         cursor.execute(
             """
-            INSERT OR REPLACE INTO conversations 
+            INSERT INTO conversations 
             (id, title, created_at, updated_at, metadata)
             VALUES (?, ?, ?, ?, ?)
             """,
             (
                 conversation.id,
                 conversation.title,
                 conversation.created_at.isoformat(),
                 conversation.updated_at.isoformat(),
                 json.dumps(conversation.metadata)
             )
         )
-        
-        # Delete existing messages
-        cursor.execute(
-            "DELETE FROM messages WHERE conversation_id = ?",
-            (conversation.id,)
-        )
-        
-        # Insert messages
-        for msg in conversation.messages:
-            cursor.execute(
-                """
-                INSERT INTO messages 
-                (conversation_id, role, content, timestamp, metadata)
-                VALUES (?, ?, ?, ?, ?)
-                """,
-                (
-                    conversation.id,
-                    msg.role,
-                    msg.content,
-                    msg.timestamp.isoformat(),
-                    json.dumps(msg.metadata)
-                )
-            )
-        
+        # Assuming messages are added separately via add_message for new conversations.
         conn.commit()

+const escapeHtml = (unsafe) => {
+    return unsafe
+         .replace(/&/g, "&")
+         .replace(/</g, "&lt;")
+         .replace(/>/g, "&gt;")
+         .replace(/"/g, "&quot;")
+         .replace(/'/g, "&#039;");
+};
+
 const messageContent = role === 'agent' ? 
     marked.parse(content) : 
-    content.replace(/\n/g, '<br>');
+    escapeHtml(content).replace(/\n/g, '<br>');

+// Make sure to include DOMPurify script, e.g., from a CDN:
+// <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/purify.min.js"></script>
+
 const messageContent = role === 'agent' ? 
-    marked.parse(content) : 
+    DOMPurify.sanitize(marked.parse(content)) : 
     content.replace(/\n/g, '<br>');

 convElement.innerHTML = `
     <div class="flex items-center justify-between">
-        <span class="truncate">${title}</span>
+        <span class="truncate"></span>
         <button class="delete-conversation text-gray-400 hover:text-red-500" data-id="${conv.id}">
             <i class="fas fa-times"></i>
         </button>
     </div>
 `;
+convElement.querySelector('.truncate').textContent = title;

+# You will need to add 'asteval' to your project's dependencies.
+# pip install asteval
+from asteval import Interpreter
+
+aeval = Interpreter()
+
 @tool
 def calculate(expression: str) -> float:
     """
     Evaluate a mathematical expression.
     
     Args:
         expression: The mathematical expression to evaluate.
         
     Returns:
         The result of the evaluation.
     """
-    # In a real implementation, use a safe evaluation
+    # Use a safe evaluation library instead of eval()
     print(f"Calculating: {expression}")
     try:
-        return eval(expression, {"__builtins__": {}}, {})
+        # The asteval Interpreter provides a safe way to evaluate expressions.
+        return aeval.eval(expression)
     except Exception as e:
         return f"Error: {str(e)}"

 # Update conversation title if it's the first message
 if len(conv.messages) == 1:
     # Generate a title based on the first message
     title = message.content[:50] + (message.content[50:] and '...')
-    storage._save_conversation(Conversation(
-        **{
-            **conv.dict(),
-            "title": title,
-            "updated_at": datetime.utcnow()
-        }
-    ))
+    
+    # Re-fetch conversation to get the latest state including the agent's message
+    updated_conv = storage.get_conversation(message.conversation_id)
+    if updated_conv:
+        updated_conv.title = title
+        updated_conv.updated_at = datetime.utcnow()
+        storage._save_conversation(updated_conv)

-user = get_user_by_username(db, username=user_in.username)
-if user:
+existing_user = get_user_by_username(db, username=user_in.username)
+if existing_user:
     raise HTTPException(
         status_code=status.HTTP_400_BAD_REQUEST,
         detail="The user with this username already exists in the system.",
     )
+
+from ...services.user import get_user_by_email
+existing_email = get_user_by_email(db, email=user_in.email)
+if existing_email:
+    raise HTTPException(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        detail="The user with this email already exists in the system.",
+    )
+
 user = create_user(db, user_in)

+# This is a conceptual fix. You would need to add logic to categorize activities.
+# For example, by asking the agent to classify each `user_activity`.
+
+# Placeholder for dynamic calculation
+work_minutes = 0
+communication_minutes = 0
+breaks_minutes = 0
+
+# Example categorization logic (to be implemented)
+# for entry in activity_log:
+#     category = remote.input(f"Categorize this activity: '{entry['user_activity']}' as work, communication, or break.")
+#     if category == 'work':
+#         work_minutes += SNAPSHOT_INTERVAL / 60
+#     ...
+
+# For now, acknowledge that it's a placeholder
+total_minutes = TOTAL_DURATION // 60
+
 # Generate summary report
 summary = {
     "date": datetime.now().strftime("%Y-%m-%d"),
-    "total_tracked_minutes": TOTAL_DURATION // 60,
+    "total_tracked_minutes": total_minutes,
     "apps_used": [{"app": app, "minutes": duration//60} for app, duration in time_spent.items()],
     "time_distribution": {
-        "work": {"minutes": int(TOTAL_DURATION * 0.7) // 60, "percentage": 70},
-        "communication": {"minutes": int(TOTAL_DURATION * 0.2) // 60, "percentage": 20},
-        "breaks": {"minutes": int(TOTAL_DURATION * 0.1) // 60, "percentage": 10}
+        # NOTE: The following is a placeholder and should be calculated dynamically
+        "work": {"minutes": int(total_minutes * 0.7), "percentage": 70},
+        "communication": {"minutes": int(total_minutes * 0.2), "percentage": 20},
+        "breaks": {"minutes": int(total_minutes * 0.1), "percentage": 10}
     },
     "key_activities": key_activities[:5],  # Top 5 key activities
     "productivity_score": 85,  # This could be calculated based on app usage patterns
     "detailed_breakdown": activities_by_app
 }

+function escapeHTML(str) {
+    const p = document.createElement("p");
+    p.textContent = str;
+    return p.innerHTML;
+}
+
 // Convert markdown to HTML if it's an agent message
 const messageContent = role === 'agent' ? 
     marked.parse(content) : 
-    content.replace(/\n/g, '<br>');
+    escapeHTML(content).replace(/\n/g, '<br>');

 convElement.innerHTML = `
     <div class="flex items-center justify-between">
-        <span class="truncate">${title}</span>
+        <span class="truncate"></span>
         <button class="delete-conversation text-gray-400 hover:text-red-500" data-id="${conv.id}">
             <i class="fas fa-times"></i>
         </button>
     </div>
 `;
+convElement.querySelector('.truncate').textContent = title;

 # In a real implementation, use a safe evaluation
+import ast
+
 print(f"Calculating: {expression}")
 try:
-    return eval(expression, {"__builtins__": {}}, {})
-except Exception as e:
-    return f"Error: {str(e)}"
+    # Use ast.literal_eval for safe evaluation of simple expressions
+    return ast.literal_eval(expression)
+except (ValueError, SyntaxError, TypeError, MemoryError) as e:
+    return f"Error: Invalid or unsafe expression. {str(e)}"